package com.mmall.service.impl;

import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.google.common.collect.Lists;
import com.mmall.common.Const;
import com.mmall.common.ResponseCode;
import com.mmall.common.ServerResponse;
import com.mmall.dao.CategoryMapper;
import com.mmall.dao.ProductMapper;
import com.mmall.pojo.Category;
import com.mmall.pojo.Product;
import com.mmall.service.ICategoryService;
import com.mmall.service.IProductService;
import com.mmall.util.DateTimeUtil;
import com.mmall.util.PropertiesUtil;
import com.mmall.vo.ProductDetailVo;
import com.mmall.vo.ProductListVo;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.List;

/**
 * Created by Administrator on 2018/11/10.
 */
@Service("iProductService")
public class ProductServiceImpl implements IProductService {

    @Autowired
    private ProductMapper productMapper;

    @Autowired
    private CategoryMapper categoryMapper;

    @Autowired
    private ICategoryService iCategoryService;  //这里属于平级（都属于service层）注入

    /**
     * 新增或者更新产品
     *
     * @param product
     * @return
     */
    public ServerResponse saveOrUpdateProduct(Product product) {
        if (product != null) {
//            判断产品子图是否存在
            if (StringUtils.isNotBlank(product.getSubImages())) {
//                分割子图路径
                String[] subImageArray = product.getSubImages().split(",");
                if (subImageArray.length > 0) {
//                    保存主图,
                    product.setMainImage(subImageArray[0]);
                }
            }

//            更新产品信息
            if (product.getId() != null) {
                int rowCount = productMapper.updateByPrimaryKey(product);
                if (rowCount > 0) {
                    return ServerResponse.createBySuccess("更新产品成功");
                }
                return ServerResponse.createBySuccess("更新产品失败");
            } else {
//                 新增产品
                int rowCount = productMapper.insert(product);
                if (rowCount > 0) {
                    return ServerResponse.createBySuccess("新增产品成功");
                }
                return ServerResponse.createByErrorMessage("新增产品失败");
            }
        }
        return ServerResponse.createByErrorMessage("新增或更新产品参数不正确");
    }

    /**
     * 产品上下架，产品销售状态
     *
     * @param productId
     * @param status
     * @return
     */
    public ServerResponse<String> setSaleStatus(Integer productId, Integer status) {
        if (productId == null || status == null) {
            return ServerResponse.createByErrocodeMessage(ResponseCode.ERROR.getCode(), ResponseCode.ILLGAL_ARGUMENT.getDesc());
        }
        Product product = new Product();
        product.setId(productId);
        product.setStatus(status);
        int rowCount = productMapper.updateByPrimaryKeySelective(product);
        if (rowCount > 0) {
            return ServerResponse.createBySuccessMessage("修改产品销售状态成功");
        }
        return ServerResponse.createByErrorMessage("修改产品销售状态失败");
    }

    /**
     * 产品详情
     *
     * @param productId
     * @return
     */
    public ServerResponse<ProductDetailVo> manageProductDetail(Integer productId) {
        if (productId == null) {
            return ServerResponse.createByErrocodeMessage(ResponseCode.ILLGAL_ARGUMENT.getCode(), ResponseCode.ILLGAL_ARGUMENT.getDesc());
        }
        Product product = productMapper.selectByPrimaryKey(productId);
        if (product == null) {
            return ServerResponse.createByErrorMessage("产品已下架或删除");
        }

//        包装VO返回给前端使用
        ProductDetailVo productDetailVo = assembleProductDetailVo(product);
        return ServerResponse.createBySuccess(productDetailVo);
    }

    @Override
    public ServerResponse<ProductDetailVo> getProductDetail(Integer productId) {
        if (productId == null) {
            return ServerResponse.createByErrocodeMessage(ResponseCode.ILLGAL_ARGUMENT.getCode(), ResponseCode.ILLGAL_ARGUMENT.getDesc());
        }
        Product product = productMapper.selectByPrimaryKey(productId);
        if (product == null) {
            return ServerResponse.createByErrorMessage("产品已下架或删除");
        }
        if (product.getStatus() != Const.ProductStatusEnum.ON_SALE.getCode()) {
            return ServerResponse.createByErrorMessage("产品已下架或删除");
        }
//        包装VO返回给前端使用
        ProductDetailVo productDetailVo = assembleProductDetailVo(product);
        return ServerResponse.createBySuccess(productDetailVo);
    }

    /**
     * 获取产品分页
     *
     * @param pageNum
     * @param pageSize
     * @return
     */
    public ServerResponse<PageInfo> getProductList(int pageNum, int pageSize) {
//        利用pagehelper分页插件实现
        PageHelper.startPage(pageNum, pageSize);
//        查询出所有产品
        List<Product> productList = productMapper.selectList();

//        List<ProductListVo>
//        遍历上面查到的产品信息列表，传给封装的VO方法处理
        List<ProductListVo> productListVoList = Lists.newArrayList();
        for (Product productItem : productList) {
            ProductListVo productListVo = assembleProductListVo(productItem);
//            因为交给assembleProductListVo（）方法处理出来的结果是一条数据，这里需要个容器装这些数据
            productListVoList.add(productListVo);
        }

//        把上述sql查询出来的结果交给pageHelper处理分页
        PageInfo pageInfo = new PageInfo(productList);
//        传入前端需要的参数列表，重置分页
        pageInfo.setList(productListVoList);
//        重置pageInfo里的List
        return ServerResponse.createBySuccess(pageInfo);
    }

    /**
     * 搜索产品详情
     *
     * @param productName
     * @param productId
     * @param pageNum
     * @param pageSize
     * @return
     */
    public ServerResponse<PageInfo> searchProduct(String productName, Integer productId, int pageNum, int pageSize) {
//        开启PageHelper
        PageHelper.startPage(pageNum, pageSize);
//        书写自己的sql逻辑，这里要判断传入的productName是否存在
        if (StringUtils.isNotBlank(productName)) {
//            拼接模糊查询条件
            productName = new StringBuilder().append("%").append(productName).append("%").toString();
        }
//        分页查询相关操作
//        查询出产品信息
        List<Product> productList = productMapper.selectByNameAndProductId(productName, productId);

//        遍历并且处理每条产品信息
        List<ProductListVo> productListVoList = Lists.newArrayList();
        for (Product productItem : productList) {
//            把遍历出来的每条产品信息赋值给VO对象的容器
            ProductListVo productListVo = assembleProductListVo(productItem);
            productListVoList.add(productListVo);
        }
//        把sql查询的结果交给PageHelper对象处理得到PageInfo
        PageInfo pageInfo = new PageInfo(productList);
//        对上面的PageInfo重新赋值，以去掉不需要返回给前端的数据
        pageInfo.setList(productListVoList);
//        将最终结果返回给前端
        return ServerResponse.createBySuccess(pageInfo);

    }

    /**
     * 根据关键字查询
     *
     * @param keyword
     * @param categoryId
     * @param pageNum
     * @param pageSize
     * @param orderBy
     * @return
     */
    @Override
    public ServerResponse<PageInfo> getProductByKeywordCategory(String keyword, Integer categoryId, int pageNum, int pageSize, String orderBy) {
        if (StringUtils.isBlank(keyword) && categoryId == null) {
            return ServerResponse.createByErrocodeMessage(ResponseCode.ILLGAL_ARGUMENT.getCode(), ResponseCode.ILLGAL_ARGUMENT.getDesc());
        }
//        实例化一个用来装入categoryId的容器
        List<Integer> categoryIdList = new ArrayList<>();
        if (categoryId != null) {
//            根据categoryId查出产品信息
            Category category = categoryMapper.selectByPrimaryKey(categoryId);
//            如果没有查出符合categoryId的商品，则分页显示
            if (category == null && StringUtils.isBlank(keyword)) {
//                开启分页查询
                PageHelper.startPage(pageNum, pageSize);
//                实例化接受查询结果的容器
                List<ProductListVo> productListVoList = Lists.newArrayList();
//                传入接受容器
                PageInfo pageInfo = new PageInfo(productListVoList);
                return ServerResponse.createBySuccess(pageInfo);
            }
//            获取category平行节点
            categoryIdList = iCategoryService.selectCategoryAndChildrenById(category.getId()).getData();
        }
//        注意：这里如果本节点有其他平行节点的话应该首先获取其平行节点信息，然后在递归每个平行节点下的子节点
//        子节点一猜类推
        if (StringUtils.isNotBlank(keyword)) {
            keyword = new StringBuilder().append("%").append(keyword).append("%").toString();
        }
//        开启分页。这里跟要放入PageInfo里进行分页的数据要分开来看
        PageHelper.startPage(pageNum, pageSize);
//        排序处理
        if (StringUtils.isNotBlank(orderBy)) {
            if (Const.ProductListOrderBy.PRICE_ASC_DESC.contains(orderBy)) {
                String[] orderByArray = orderBy.split("_");
                PageHelper.orderBy(orderByArray[0] + "" + orderByArray[1]);
            }
        }
//        根据id和keyword查询出Product信息
        List<Product> productList = productMapper.selectByNameAndCategoryIds(StringUtils.isBlank(keyword) ? null : keyword, categoryIdList.size() == 0 ? null : categoryIdList);
//        创建一个前端产品封装，容器
        List<ProductListVo> productListVoList = Lists.newArrayList();
        for (Product product : productList) {
            ProductListVo productListVo = assembleProductListVo(product);
            productListVoList.add(productListVo);
        }
//        放入PageInfo，进行分页
        PageInfo pageInfo = new PageInfo(productList);
        pageInfo.setList(productListVoList);
        return ServerResponse.createBySuccess(pageInfo);
    }

    //    封装产品分页的VO
    private ProductListVo assembleProductListVo(Product product) {
//        封装前端返回参数的容器
        ProductListVo productListVo = new ProductListVo();

        productListVo.setId(product.getId());
        productListVo.setName(product.getName());
        productListVo.setCategoryId(product.getCategoryId());
        productListVo.setImageHost(PropertiesUtil.getProperty("ftp.server.http.prefix", "http://img.happymmall.com/"));
        productListVo.setMainImage(product.getMainImage());
        productListVo.setPrice(product.getPrice());
        productListVo.setSubtitle(product.getSubtitle());
        productListVo.setStatus(product.getStatus());
        return productListVo;
    }

    //    封装VO返回给前端用
    private ProductDetailVo assembleProductDetailVo(Product product) {
        ProductDetailVo productDetailVo = new ProductDetailVo();

        productDetailVo.setId(product.getId());
        productDetailVo.setSubtitle(product.getSubtitle());
        productDetailVo.setPrice(product.getPrice());
        productDetailVo.setMainImage(product.getMainImage());
        productDetailVo.setSubImages(product.getSubImages());
        productDetailVo.setCategoryId(product.getCategoryId());
        productDetailVo.setDetail(product.getDetail());
        productDetailVo.setName(product.getName());
        productDetailVo.setStatus(product.getStatus());
        productDetailVo.setStock(product.getStock());
//        设置图片服务器路径
        productDetailVo.setImageHost(PropertiesUtil.getProperty("ftp.server.http.prefix", "http://img.hotant.top/"));
//        根据产品id查询出产品信息
        Category category = categoryMapper.selectByPrimaryKey(product.getCategoryId());
        if (category == null) {
//            如果没有查询出产品信息，则默认产品id为0
            productDetailVo.setParentCategoryId(0);
        } else {
            productDetailVo.setParentCategoryId(category.getParentId());
        }
//        设置时间
        productDetailVo.setCreateTime(DateTimeUtil.dateToStr(product.getCreateTime()));
        productDetailVo.setUpdateTime(DateTimeUtil.dateToStr(product.getUpdateTime()));
        return productDetailVo;
    }


}
